home *** CD-ROM | disk | FTP | other *** search
/ PC Plus SuperCD (UK) 1995 March / PC Plus Super CD (Issue 101) (March 1995).iso / tclite / include / object.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-27  |  7.3 KB  |  199 lines
  1. #ifndef OBJECT_H
  2. #define OBJECT_H
  3.  
  4. #include <iostream.h>
  5.  
  6. typedef int bool;
  7. const bool YES = 1;
  8. const bool NO = 0;
  9.  
  10. inline int           ABS(int x) { return x >= 0 ? x : -x; }
  11. inline long          ABS(long x)    { return x >= 0 ? x : -x; }
  12. inline double        ABS(double x)  { return x >= 0 ? x : -x; }
  13. inline int           MAX(int a,int b)   { return a >= b ? a : b; }
  14. inline long          MAX(long a,long b) { return a >= b ? a : b; }
  15. inline double        MAX(double a,double b) { return a >= b ? a : b; }
  16. inline unsigned int  MAX(unsigned int a, unsigned int b)
  17.                         { return a >= b ? a : b; }
  18. inline unsigned long MAX(unsigned long a, unsigned long b)
  19.                         { return a >= b ? a : b; }
  20. inline int           MIN(int a,int b)   { return a <= b ? a : b; }
  21. inline long          MIN(long a,long b) { return a <= b ? a : b; }
  22. inline double        MIN(double a,double b) { return a <= b ? a : b; }
  23. inline unsigned int  MIN(unsigned int a, unsigned int b)
  24.                         { return a <= b ? a : b; }
  25. inline unsigned long MIN(unsigned long a, unsigned long b)
  26.                         { return a <= b ? a : b; }
  27.  
  28.  
  29. ////////////////////////////////////////////////////////////
  30. // macro DEFINE_CLASS
  31. ////////////////////////////////////////////////////////////
  32. #define DEFINE_CLASS(classname, basename)                    \
  33. const Class class_##classname = Class( class_##basename,     \
  34.                                        #classname,           \
  35.                                        sizeof(classname));   \
  36. const Class* classname::isA() const { return &class_##classname; }
  37.  
  38. class Class;        // forward reference for Object
  39. ////////////////////////////////////////////////////////////
  40. // class Object
  41. ////////////////////////////////////////////////////////////
  42. class Object
  43. {
  44. protected:
  45.     Object() {}
  46. public:
  47.     const Class* baseClass() const;
  48.     const char* className() const;
  49.  
  50.                 // unimplemented virtual function
  51.     void    derivedClassResponsibility(const char*) const;
  52.                 // invalid object class error
  53.     void    invalidArgClass(const Object& ob,    
  54.                             const Class& expect,
  55.                             const char* fname) const;
  56.                 // invalid object species error
  57.     void    invalidArgSpecies(const Object& ob, 
  58.                               const Class& expect,
  59.                               const char* fname) const;
  60.                 // class cannot implement this function
  61.     void    shouldNotImplement(const char*) const;    
  62.     void    assertArgClass(const Object& ob,    // validate argument class
  63.                            const Class& expect,
  64.                            const char* fname) const;
  65.     void    assertArgSpecies(const Object& ob,   // validate argument species
  66.                              const Class& expect,
  67.                              const char* fname) const;
  68.                 // YES if MemberOf class or a superclass
  69.     bool    isKindOf(const Class&) const;  
  70.     bool    isSame(const Object& ob) const     { return this==&ob; }
  71.     bool    isSpecies(const Class& clid) const { return species()==&clid; }
  72.  
  73.     virtual void printOn(ostream& strm) const;
  74.     virtual unsigned hash() const;      // calculate object hash
  75.     virtual const Class* isA() const;   // return class descriptor address
  76.     virtual bool isEqual(const Object&) const;  // equality test
  77.     virtual int compare(const Object&) const;   // compare objects
  78.     virtual unsigned capacity() const;  // subclass capacity
  79.     virtual Object* copy() const;       // copy defaulted as deepCopy
  80.     virtual Object* deepCopy() const;   // copy with distinct
  81.                                         // instance variables
  82.     virtual void deepenShallowCopy();   // convert shallow copy to deep copy
  83.     virtual Object* shallowCopy() const;// copy with shared
  84.                                         // instance variables
  85.     virtual unsigned size() const;      // # of objects in
  86.                                         // array/container subclass
  87.     virtual const Class* species() const;   // return species class
  88.                                             // descriptor address
  89. };
  90.  
  91.  
  92.  
  93.  
  94. ////////////////////////////////////////////////////////////
  95. // class Class
  96. ////////////////////////////////////////////////////////////
  97. class Class : public Object
  98. {
  99.     const Class* superClass;
  100.     Class* nextClass;
  101.     const char* class_name;
  102.     unsigned inst_size;         // size of instance variables
  103. public:
  104.     Class(const Class& super, const char* name, unsigned size);
  105.     const Class* baseClass() const                { return superClass; }
  106.     const char* className() const                 { return class_name; }
  107.     virtual void printOn(ostream& strm) const;
  108.  
  109.     virtual bool isEqual(const Object&) const;    // equality test
  110.     virtual unsigned size() const;
  111.     virtual const Class* isA() const;
  112. };
  113.  
  114.  
  115. extern const Class class_Class; // Class of Classes 
  116. extern const Class class_Object;
  117.  
  118.  
  119. extern const Object* const nil; // pointer to sole instance of nil object
  120.  
  121. inline const Class* Object::baseClass() const
  122. {
  123.     return isA()->baseClass();
  124. }
  125.  
  126. inline const char* Object::className() const
  127. {
  128.     return isA()->className();
  129. }
  130.  
  131.  
  132. inline ostream& operator<<(ostream& strm, const Object& ob)
  133. {
  134.     ob.printOn(strm);
  135.     return strm;
  136. }
  137.  
  138.  
  139. void DTerror(const char* s1, const char* s2);
  140.  
  141.                 // invalid argument class error
  142. extern void invalidArgClass(const Object& ob,
  143.                             const Class& expect,
  144.                             const char* fname);
  145.                 // invalid argument species error
  146. extern void invalidArgSpecies(const Object& ob,
  147.                               const Class& expect,
  148.                               const char* fname);
  149.                 // invalid object class error
  150. extern void invalidClass(const Object& ob,
  151.                          const Class& expect);
  152.                 // invalid object species error
  153. extern void invalidSpecies(const Object& ob,
  154.                            const Class& expect);          
  155.  
  156.  
  157.  
  158. inline void assertArgClass(const Object& ob,
  159.                            const Class& expect,
  160.                            const char* fname)
  161. {
  162.     if (!((ob).isKindOf(expect))) ::invalidArgClass(ob,expect,fname);
  163. }
  164.  
  165. inline void assertArgSpecies(const Object& ob,
  166.                              const Class& expect,
  167.                              const char* fname) const
  168. {
  169.     if (!((ob).isSpecies(expect))) ::invalidArgSpecies(ob,expect,fname);
  170. }
  171.  
  172. inline void Object::assertArgClass(const Object& ob,
  173.                                    const Class& expect,
  174.                                    const char* fname) const
  175. {
  176.     if (!((ob).isKindOf(expect))) this->invalidArgClass(ob,expect,fname);
  177. }
  178.  
  179. inline void Object::assertArgSpecies(const Object& ob,
  180.                                      const Class& expect,
  181.                                      const char* fname) const
  182. {
  183.     if (!((ob).isSpecies(expect)))
  184.         this->invalidArgSpecies(ob,expect,fname);
  185. }
  186.  
  187. inline void assertClass(const Object& ob, const Class& expect)
  188. {
  189.     if (!((ob).isKindOf(expect))) ::invalidClass(ob,expect);
  190. }
  191.  
  192. inline void assertSpecies(const Object& ob, const Class& expect)
  193. {
  194.     if (!((ob).isSpecies(expect))) ::invalidSpecies(ob,expect);
  195. }
  196.  
  197. #endif
  198.  
  199.